ಪೈಥಾನ್ ಪಾಂಡಾಸ್ನಲ್ಲಿ ಡೇಟಾಫ್ರೇಮ್ಗಳನ್ನು ವಿಲೀನಗೊಳಿಸುವ ಮತ್ತು ಸೇರುವ ಬಗ್ಗೆ ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿ, ಜಾಗತಿಕ ಡೇಟಾ ವಿಶ್ಲೇಷಣೆಗಾಗಿ ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳೊಂದಿಗೆ ವಿವಿಧ ತಂತ್ರಗಳನ್ನು ಒಳಗೊಂಡಿದೆ.
ಪೈಥಾನ್ ಪಾಂಡಾಸ್ ವಿಲೀನಗೊಳಿಸುವಿಕೆ: ಡೇಟಾ ವಿಶ್ಲೇಷಣೆಗಾಗಿ ಡೇಟಾಫ್ರೇಮ್ ಸೇರುವಿಕೆ ತಂತ್ರಗಳನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳುವುದು
ಡೇಟಾ ವಿಶ್ಲೇಷಣೆಯ ಒಂದು ನಿರ್ಣಾಯಕ ಅಂಶವೆಂದರೆ ಡೇಟಾ ಮ್ಯಾನಿಪ್ಯುಲೇಷನ್, ಮತ್ತು ಪೈಥಾನ್ನಲ್ಲಿರುವ ಪಾಂಡಾಸ್ ಲೈಬ್ರರಿಯು ಈ ಉದ್ದೇಶಕ್ಕಾಗಿ ಶಕ್ತಿಯುತ ಪರಿಕರಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ. ಈ ಪರಿಕರಗಳಲ್ಲಿ, ಡೇಟಾಫ್ರೇಮ್ಗಳನ್ನು ವಿಲೀನಗೊಳಿಸುವುದು ಮತ್ತು ಸೇರಿಸುವುದು ಸಾಮಾನ್ಯ ಕಾಲಮ್ಗಳು ಅಥವಾ ಸೂಚ್ಯಂಕಗಳ ಆಧಾರದ ಮೇಲೆ ಡೇಟಾಸೆಟ್ಗಳನ್ನು ಸಂಯೋಜಿಸಲು ಅಗತ್ಯವಾದ ಕಾರ್ಯಾಚರಣೆಗಳಾಗಿವೆ. ಈ ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿಯು ಪಾಂಡಾಸ್ನಲ್ಲಿನ ವಿವಿಧ ಡೇಟಾಫ್ರೇಮ್ ಸೇರ್ಪಡೆ ತಂತ್ರಗಳನ್ನು ಅನ್ವೇಷಿಸುತ್ತದೆ, ವಿವಿಧ ಮೂಲಗಳಿಂದ ಡೇಟಾವನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಸಂಯೋಜಿಸಲು ಮತ್ತು ವಿಶ್ಲೇಷಿಸಲು ನಿಮಗೆ ಜ್ಞಾನವನ್ನು ನೀಡುತ್ತದೆ.
ಡೇಟಾಫ್ರೇಮ್ ವಿಲೀನ ಮತ್ತು ಸೇರ್ಪಡೆಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು
ಡೇಟಾಫ್ರೇಮ್ಗಳನ್ನು ವಿಲೀನಗೊಳಿಸುವುದು ಮತ್ತು ಸೇರಿಸುವುದು ಎಂದರೆ ಹಂಚಿಕೆಯ ಕಾಲಮ್ ಅಥವಾ ಸೂಚ್ಯಂಕದ ಆಧಾರದ ಮೇಲೆ ಎರಡು ಅಥವಾ ಹೆಚ್ಚಿನ ಡೇಟಾಫ್ರೇಮ್ಗಳನ್ನು ಒಂದೇ ಡೇಟಾಫ್ರೇಮ್ಗೆ ಸಂಯೋಜಿಸುವುದು. `merge` ಮತ್ತು `join` ನಡುವಿನ ಪ್ರಮುಖ ವ್ಯತ್ಯಾಸವೆಂದರೆ, `merge` ಎಂಬುದು ಪಾಂಡಾಸ್ ಲೈಬ್ರರಿಯ ಒಂದು ಕಾರ್ಯವಾಗಿದ್ದು, ಸಾಮಾನ್ಯವಾಗಿ ಡೇಟಾಫ್ರೇಮ್ಗಳನ್ನು ಕಾಲಮ್ಗಳ ಮೇಲೆ ಸೇರಿಸುತ್ತದೆ, ಆದರೆ `join` ಎಂಬುದು ಡೇಟಾಫ್ರೇಮ್ ವಿಧಾನವಾಗಿದ್ದು, ಇದನ್ನು ಕಾಲಮ್ಗಳೊಂದಿಗೆ ಸಹ ಬಳಸಬಹುದಾದರೂ, ಮುಖ್ಯವಾಗಿ ಸೂಚ್ಯಂಕಗಳ ಮೇಲೆ ಡೇಟಾಫ್ರೇಮ್ಗಳನ್ನು ಸೇರಿಸುತ್ತದೆ.
ಪ್ರಮುಖ ಪರಿಕಲ್ಪನೆಗಳು
- ಡೇಟಾಫ್ರೇಮ್ಗಳು: ವಿಭಿನ್ನ ಪ್ರಕಾರಗಳ ಕಾಲಮ್ಗಳನ್ನು ಹೊಂದಿರುವ ಎರಡು ಆಯಾಮದ ಲೇಬಲ್ ಮಾಡಲಾದ ಡೇಟಾ ರಚನೆಗಳು.
- ಸಾಮಾನ್ಯ ಕಾಲಮ್ಗಳು/ಸೂಚ್ಯಂಕಗಳು: ಡೇಟಾಫ್ರೇಮ್ಗಳಲ್ಲಿ ಒಂದೇ ಹೆಸರು ಮತ್ತು ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ಹಂಚಿಕೊಳ್ಳುವ ಕಾಲಮ್ಗಳು ಅಥವಾ ಸೂಚ್ಯಂಕಗಳು, ವಿಲೀನಗೊಳಿಸುವಿಕೆ/ಸೇರುವಿಕೆಗೆ ಆಧಾರವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ.
- ಸೇರ್ಪಡೆ ವಿಧಗಳು: ವಿಲೀನಗೊಳಿಸುವಿಕೆ/ಸೇರುವಿಕೆ ಪ್ರಕ್ರಿಯೆಯ ಸಮಯದಲ್ಲಿ ಹೊಂದಾಣಿಕೆಯಾಗದ ಸಾಲುಗಳನ್ನು ನಿರ್ವಹಿಸಲು ವಿವಿಧ ತಂತ್ರಗಳು, ಆಂತರಿಕ, ಬಾಹ್ಯ, ಎಡ ಮತ್ತು ಬಲ ಸೇರ್ಪಡೆಗಳು ಸೇರಿದಂತೆ.
`pd.merge()` ನೊಂದಿಗೆ ಡೇಟಾಫ್ರೇಮ್ ವಿಲೀನಗೊಳಿಸುವಿಕೆ
`pd.merge()` ಕಾರ್ಯವು ಕಾಲಮ್ಗಳ ಆಧಾರದ ಮೇಲೆ ಡೇಟಾಫ್ರೇಮ್ಗಳನ್ನು ವಿಲೀನಗೊಳಿಸಲು ಪ್ರಮುಖ ಸಾಧನವಾಗಿದೆ. ಇದು ಒಂದು ಅಥವಾ ಹೆಚ್ಚಿನ ಸಾಮಾನ್ಯ ಕಾಲಮ್ಗಳ ಆಧಾರದ ಮೇಲೆ ಡೇಟಾವನ್ನು ಸಂಯೋಜಿಸಲು ಹೊಂದಿಕೊಳ್ಳುವ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ.
ಸಿಂಟ್ಯಾಕ್ಸ್
pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=False, suffixes=('_x', '_y'), copy=True, indicator=False, validate=None)
ಪ್ಯಾರಾಮೀಟರ್ಗಳು
- left: ವಿಲೀನಗೊಳಿಸಬೇಕಾದ ಎಡ ಡೇಟಾಫ್ರೇಮ್.
- right: ವಿಲೀನಗೊಳಿಸಬೇಕಾದ ಬಲ ಡೇಟಾಫ್ರೇಮ್.
- how: ನಿರ್ವಹಿಸಬೇಕಾದ ವಿಲೀನದ ಪ್ರಕಾರ ('inner', 'outer', 'left', 'right'). ಡೀಫಾಲ್ಟ್ 'inner'.
- on: ಸೇರಲು ಬಳಸುವ ಕಾಲಮ್(ಗಳ) ಹೆಸರು. ಇವು ಎರಡೂ ಡೇಟಾಫ್ರೇಮ್ಗಳಲ್ಲಿ ಕಂಡುಬರಬೇಕು.
- left_on: ಎಡ ಡೇಟಾಫ್ರೇಮ್ನಲ್ಲಿ ಸೇರ್ಪಡೆ ಕೀಲಿಗಳಾಗಿ ಬಳಸಬೇಕಾದ ಕಾಲಮ್(ಗಳ) ಹೆಸರು.
- right_on: ಬಲ ಡೇಟಾಫ್ರೇಮ್ನಲ್ಲಿ ಸೇರ್ಪಡೆ ಕೀಲಿಗಳಾಗಿ ಬಳಸಬೇಕಾದ ಕಾಲಮ್(ಗಳ) ಹೆಸರು.
- left_index: True ಆಗಿದ್ದರೆ, ಎಡ ಡೇಟಾಫ್ರೇಮ್ನಿಂದ ಸೂಚ್ಯಂಕವನ್ನು ಸೇರ್ಪಡೆ ಕೀಲಿ(ಗಳ) ಆಗಿ ಬಳಸಿ.
- right_index: True ಆಗಿದ್ದರೆ, ಬಲ ಡೇಟಾಫ್ರೇಮ್ನಿಂದ ಸೂಚ್ಯಂಕವನ್ನು ಸೇರ್ಪಡೆ ಕೀಲಿ(ಗಳ) ಆಗಿ ಬಳಸಿ.
- sort: ಸೇರ್ಪಡೆ ಕೀಲಿಗಳ ಮೂಲಕ ಫಲಿತಾಂಶದ ಡೇಟಾಫ್ರೇಮ್ ಅನ್ನು ಲೆಕ್ಸಿಕೋಗ್ರಾಫಿಕಲಿ ವಿಂಗಡಿಸಿ. ಡೀಫಾಲ್ಟ್ False.
- suffixes: ಅತಿಕ್ರಮಿಸುವ ಕಾಲಮ್ ಹೆಸರುಗಳಿಗೆ ಅನ್ವಯಿಸಲು ಸ್ಟ್ರಿಂಗ್ ಸಫಿಕ್ಸ್ಗಳ ಟುಪಲ್. ಡೀಫಾಲ್ಟ್ ('_x', '_y').
- copy: False ಆಗಿದ್ದರೆ, ಸಾಧ್ಯವಾದೆಡೆ ಹೊಸ ಡೇಟಾಫ್ರೇಮ್ಗೆ ಡೇಟಾವನ್ನು ನಕಲಿಸುವುದನ್ನು ತಪ್ಪಿಸಿ. ಡೀಫಾಲ್ಟ್ True.
- indicator: True ಆಗಿದ್ದರೆ, ಪ್ರತಿ ಸಾಲಿನ ಮೂಲವನ್ನು ಸೂಚಿಸುವ '_merge' ಎಂಬ ಕಾಲಮ್ ಅನ್ನು ಸೇರಿಸುತ್ತದೆ.
- validate: ವಿಲೀನವು ನಿರ್ದಿಷ್ಟ ಪ್ರಕಾರದದ್ದಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ. "one_to_one", "one_to_many", "many_to_one", "many_to_many".
ಸೇರ್ಪಡೆ ವಿಧಗಳನ್ನು ವಿವರಿಸಲಾಗಿದೆ
`how` ಪ್ಯಾರಾಮೀಟರ್ `pd.merge()` ನಲ್ಲಿ ನಿರ್ವಹಿಸಲಾದ ಸೇರ್ಪಡೆಯ ಪ್ರಕಾರವನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ. ವಿಭಿನ್ನ ಸೇರ್ಪಡೆ ವಿಧಗಳು ಹೊಂದಾಣಿಕೆಯಾಗದ ಸಾಲುಗಳನ್ನು ವಿಭಿನ್ನ ರೀತಿಯಲ್ಲಿ ನಿರ್ವಹಿಸುತ್ತವೆ.
ಆಂತರಿಕ ಸೇರ್ಪಡೆ
ಒಂದು ಆಂತರಿಕ ಸೇರ್ಪಡೆ (inner join) ಸೇರ್ಪಡೆ ಕೀಲಿಗಳ ಆಧಾರದ ಮೇಲೆ ಎರಡೂ ಡೇಟಾಫ್ರೇಮ್ಗಳಲ್ಲಿ ಹೊಂದಾಣಿಕೆಯ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿರುವ ಸಾಲುಗಳನ್ನು ಮಾತ್ರ ಹಿಂದಿರುಗಿಸುತ್ತದೆ. ಹೊಂದಾಣಿಕೆಯಾಗದ ಮೌಲ್ಯಗಳಿರುವ ಸಾಲುಗಳನ್ನು ಫಲಿತಾಂಶದಿಂದ ಹೊರಗಿಡಲಾಗುತ್ತದೆ.
ಉದಾಹರಣೆ:
ಎರಡು ಡೇಟಾಫ್ರೇಮ್ಗಳನ್ನು ಪರಿಗಣಿಸಿ:
import pandas as pd
# DataFrame 1: Customer Orders
df_orders = pd.DataFrame({
'order_id': [1, 2, 3, 4, 5],
'customer_id': [101, 102, 103, 104, 105],
'product_id': [1, 2, 1, 3, 2],
'quantity': [2, 1, 3, 1, 2]
})
# DataFrame 2: Customer Information
df_customers = pd.DataFrame({
'customer_id': [101, 102, 103, 106],
'customer_name': ['Alice', 'Bob', 'Charlie', 'David'],
'country': ['USA', 'Canada', 'UK', 'Australia']
})
# Inner Join
df_inner = pd.merge(df_orders, df_customers, on='customer_id', how='inner')
print(df_inner)
ಔಟ್ಪುಟ್:
order_id customer_id product_id quantity customer_name country
0 1 101 1 2 Alice USA
1 2 102 2 1 Bob Canada
2 3 103 1 3 Charlie UK
ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ಆಂತರಿಕ ಸೇರ್ಪಡೆಯು (inner join) `customer_id` ಕಾಲಮ್ನ ಆಧಾರದ ಮೇಲೆ `df_orders` ಮತ್ತು `df_customers` ಡೇಟಾಫ್ರೇಮ್ಗಳನ್ನು ಸಂಯೋಜಿಸುತ್ತದೆ. ಆದೇಶಗಳನ್ನು ನೀಡಿದ ಗ್ರಾಹಕರನ್ನು ಮಾತ್ರ ಫಲಿತಾಂಶದಲ್ಲಿ ಸೇರಿಸಲಾಗಿದೆ. ಗ್ರಾಹಕ 'ಡೇವಿಡ್' (customer_id 106) ಅವರನ್ನು ಹೊರಗಿಡಲಾಗಿದೆ ಏಕೆಂದರೆ ಅವರಿಗೆ ಯಾವುದೇ ಆದೇಶಗಳಿಲ್ಲ.
ಬಾಹ್ಯ ಸೇರ್ಪಡೆ (ಪೂರ್ಣ ಬಾಹ್ಯ ಸೇರ್ಪಡೆ)
ಬಾಹ್ಯ ಸೇರ್ಪಡೆಯು (outer join) ಹೊಂದಾಣಿಕೆಯಾಗದ ಸಾಲುಗಳು ಸೇರಿದಂತೆ ಎರಡೂ ಡೇಟಾಫ್ರೇಮ್ಗಳಿಂದ ಎಲ್ಲಾ ಸಾಲುಗಳನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ. ಒಂದು ಸಾಲಿಗೆ ಇನ್ನೊಂದು ಡೇಟಾಫ್ರೇಮ್ನಲ್ಲಿ ಹೊಂದಾಣಿಕೆ ಇಲ್ಲದಿದ್ದರೆ, ಅನುಗುಣವಾದ ಕಾಲಮ್ಗಳು `NaN` (ಸಂಖ್ಯೆಯಲ್ಲ) ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ.
ಉದಾಹರಣೆ:
# Outer Join
df_outer = pd.merge(df_orders, df_customers, on='customer_id', how='outer')
print(df_outer)
ಔಟ್ಪುಟ್:
order_id customer_id product_id quantity customer_name country
0 1.0 101 1.0 2.0 Alice USA
1 2.0 102 2.0 1.0 Bob Canada
2 3.0 103 1.0 3.0 Charlie UK
3 4.0 104 3.0 1.0 NaN NaN
4 5.0 105 2.0 2.0 NaN NaN
5 NaN 106 NaN NaN David Australia
ಬಾಹ್ಯ ಸೇರ್ಪಡೆಯು (outer join) ಎಲ್ಲಾ ಗ್ರಾಹಕರು ಮತ್ತು ಎಲ್ಲಾ ಆದೇಶಗಳನ್ನು ಒಳಗೊಂಡಿದೆ. ಗ್ರಾಹಕರು 104 ಮತ್ತು 105 ಆದೇಶಗಳನ್ನು ಹೊಂದಿದ್ದಾರೆ ಆದರೆ ಯಾವುದೇ ಗ್ರಾಹಕರ ಮಾಹಿತಿಯಿಲ್ಲ, ಮತ್ತು ಗ್ರಾಹಕ 106 ಗ್ರಾಹಕರ ಮಾಹಿತಿಯನ್ನು ಹೊಂದಿದ್ದಾರೆ ಆದರೆ ಯಾವುದೇ ಆದೇಶಗಳಿಲ್ಲ. ಕಾಣೆಯಾದ ಮೌಲ್ಯಗಳನ್ನು `NaN` ಎಂದು ಪ್ರತಿನಿಧಿಸಲಾಗುತ್ತದೆ.
ಎಡ ಸೇರ್ಪಡೆ
ಎಡ ಸೇರ್ಪಡೆಯು (left join) ಎಡ ಡೇಟಾಫ್ರೇಮ್ನಿಂದ ಎಲ್ಲಾ ಸಾಲುಗಳನ್ನು ಮತ್ತು ಬಲ ಡೇಟಾಫ್ರೇಮ್ನಿಂದ ಹೊಂದಾಣಿಕೆಯ ಸಾಲುಗಳನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ. ಎಡ ಡೇಟಾಫ್ರೇಮ್ನಲ್ಲಿರುವ ಒಂದು ಸಾಲಿಗೆ ಬಲ ಡೇಟಾಫ್ರೇಮ್ನಲ್ಲಿ ಹೊಂದಾಣಿಕೆ ಇಲ್ಲದಿದ್ದರೆ, ಬಲ ಡೇಟಾಫ್ರೇಮ್ನಿಂದ ಅನುಗುಣವಾದ ಕಾಲಮ್ಗಳು `NaN` ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ.
ಉದಾಹರಣೆ:
# Left Join
df_left = pd.merge(df_orders, df_customers, on='customer_id', how='left')
print(df_left)
ಔಟ್ಪುಟ್:
order_id customer_id product_id quantity customer_name country
0 1 101 1 2 Alice USA
1 2 102 2 1 Bob Canada
2 3 103 1 3 Charlie UK
3 4 104 3 1 NaN NaN
4 5 105 2 2 NaN NaN
ಎಡ ಸೇರ್ಪಡೆಯು (left join) `df_orders` ನಿಂದ ಎಲ್ಲಾ ಆದೇಶಗಳನ್ನು ಒಳಗೊಂಡಿದೆ. ಗ್ರಾಹಕರು 104 ಮತ್ತು 105 ಆದೇಶಗಳನ್ನು ಹೊಂದಿದ್ದಾರೆ ಆದರೆ ಯಾವುದೇ ಗ್ರಾಹಕರ ಮಾಹಿತಿಯಿಲ್ಲ, ಆದ್ದರಿಂದ ಆ ಆದೇಶಗಳಿಗೆ `customer_name` ಮತ್ತು `country` ಕಾಲಮ್ಗಳು `NaN` ಆಗಿರುತ್ತವೆ.
ಬಲ ಸೇರ್ಪಡೆ
ಬಲ ಸೇರ್ಪಡೆಯು (right join) ಬಲ ಡೇಟಾಫ್ರೇಮ್ನಿಂದ ಎಲ್ಲಾ ಸಾಲುಗಳನ್ನು ಮತ್ತು ಎಡ ಡೇಟಾಫ್ರೇಮ್ನಿಂದ ಹೊಂದಾಣಿಕೆಯ ಸಾಲುಗಳನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ. ಬಲ ಡೇಟಾಫ್ರೇಮ್ನಲ್ಲಿರುವ ಒಂದು ಸಾಲಿಗೆ ಎಡ ಡೇಟಾಫ್ರೇಮ್ನಲ್ಲಿ ಹೊಂದಾಣಿಕೆ ಇಲ್ಲದಿದ್ದರೆ, ಎಡ ಡೇಟಾಫ್ರೇಮ್ನಿಂದ ಅನುಗುಣವಾದ ಕಾಲಮ್ಗಳು `NaN` ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ.
ಉದಾಹರಣೆ:
# Right Join
df_right = pd.merge(df_orders, df_customers, on='customer_id', how='right')
print(df_right)
ಔಟ್ಪುಟ್:
order_id customer_id product_id quantity customer_name country
0 1.0 101 1.0 2.0 Alice USA
1 2.0 102 2.0 1.0 Bob Canada
2 3.0 103 1.0 3.0 Charlie UK
3 NaN 106 NaN NaN David Australia
ಬಲ ಸೇರ್ಪಡೆಯು (right join) `df_customers` ನಿಂದ ಎಲ್ಲಾ ಗ್ರಾಹಕರನ್ನು ಒಳಗೊಂಡಿದೆ. ಗ್ರಾಹಕ 106 ಗ್ರಾಹಕರ ಮಾಹಿತಿಯನ್ನು ಹೊಂದಿದ್ದಾರೆ ಆದರೆ ಯಾವುದೇ ಆದೇಶಗಳಿಲ್ಲ, ಆದ್ದರಿಂದ ಆ ಗ್ರಾಹಕರಿಗೆ `order_id`, `product_id`, ಮತ್ತು `quantity` ಕಾಲಮ್ಗಳು `NaN` ಆಗಿರುತ್ತವೆ.
`df.join()` ನೊಂದಿಗೆ ಡೇಟಾಫ್ರೇಮ್ ಸೇರ್ಪಡೆ
`df.join()` ವಿಧಾನವನ್ನು ಮುಖ್ಯವಾಗಿ ಡೇಟಾಫ್ರೇಮ್ಗಳನ್ನು ಅವುಗಳ ಸೂಚ್ಯಂಕಗಳ ಆಧಾರದ ಮೇಲೆ ಸೇರಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ. ಇದನ್ನು ಕಾಲಮ್ಗಳ ಮೇಲೆ ಸೇರಿಸಲು ಸಹ ಬಳಸಬಹುದು, ಆದರೆ ಕಾಲಮ್-ಆಧಾರಿತ ಸೇರ್ಪಡೆಗಳಿಗಾಗಿ `pd.merge()` ಅನ್ನು ಬಳಸುವುದು ಸಾಮಾನ್ಯವಾಗಿ ಹೆಚ್ಚು ಅನುಕೂಲಕರವಾಗಿದೆ.
ಸಿಂಟ್ಯಾಕ್ಸ್
DataFrame.join(other, on=None, how='left', lsuffix='', rsuffix='', sort=False)
ಪ್ಯಾರಾಮೀಟರ್ಗಳು
- other: ಸೇರಿಸಬೇಕಾದ ಇನ್ನೊಂದು ಡೇಟಾಫ್ರೇಮ್.
- on: ಸೇರಲು ಬಳಸುವ ಕಾಲಮ್ ಹೆಸರು. ಸೂಚ್ಯಂಕವನ್ನು ಸೇರ್ಪಡೆ ಕೀಲಿಯಾಗಿ ಬಳಸದಿದ್ದರೆ ಇದನ್ನು ಪಾಸ್ ಮಾಡಬೇಕು.
- how: ಎಡ ಮತ್ತು ಬಲ ಸೆಟ್ಗಳ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸಬೇಕು. ಡೀಫಾಲ್ಟ್ 'left'.
- lsuffix: ಅತಿಕ್ರಮಿಸುವ ಕಾಲಮ್ ಹೆಸರುಗಳನ್ನು ಅತಿಕ್ರಮಿಸಲು ಎಡ ಡೇಟಾಫ್ರೇಮ್ನಿಂದ ಬಳಸಬೇಕಾದ ಸಫಿಕ್ಸ್.
- rsuffix: ಅತಿಕ್ರಮಿಸುವ ಕಾಲಮ್ ಹೆಸರುಗಳನ್ನು ಅತಿಕ್ರಮಿಸಲು ಬಲ ಡೇಟಾಫ್ರೇಮ್ನಿಂದ ಬಳಸಬೇಕಾದ ಸಫಿಕ್ಸ್.
- sort: ಸೇರ್ಪಡೆ ಕೀಲಿಗಳ ಮೂಲಕ ಫಲಿತಾಂಶದ ಡೇಟಾಫ್ರೇಮ್ ಅನ್ನು ಲೆಕ್ಸಿಕೋಗ್ರಾಫಿಕಲಿ ವಿಂಗಡಿಸಿ. ಡೀಫಾಲ್ಟ್ False.
ಸೂಚ್ಯಂಕದ ಮೇಲೆ ಸೇರ್ಪಡೆ
ಸೂಚ್ಯಂಕದ ಮೇಲೆ ಸೇರುವಾಗ, `on` ಪ್ಯಾರಾಮೀಟರ್ ಅನ್ನು ಬಳಸಲಾಗುವುದಿಲ್ಲ.
ಉದಾಹರಣೆ:
# DataFrame 1: Customer Orders with Customer ID as Index
df_orders_index = df_orders.set_index('customer_id')
# DataFrame 2: Customer Information with Customer ID as Index
df_customers_index = df_customers.set_index('customer_id')
# Join on Index (Left Join)
df_join_index = df_orders_index.join(df_customers_index, how='left')
print(df_join_index)
ಔಟ್ಪುಟ್:
order_id product_id quantity customer_name country
customer_id
101 1 1 2 Alice USA
102 2 2 1 Bob Canada
103 3 1 3 Charlie UK
104 4 3 1 NaN NaN
105 5 2 2 NaN NaN
ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, `join()` ವಿಧಾನವನ್ನು ಸೂಚ್ಯಂಕದ (`customer_id`) ಮೇಲೆ ಎಡ ಸೇರ್ಪಡೆ ಮಾಡಲು ಬಳಸಲಾಗುತ್ತದೆ. ಫಲಿತಾಂಶವು `pd.merge()` ಬಳಸಿದ ಎಡ ಸೇರ್ಪಡೆಗೆ ಹೋಲುತ್ತದೆ, ಆದರೆ ಸೇರ್ಪಡೆಯು ಕಾಲಮ್ನ ಬದಲಿಗೆ ಸೂಚ್ಯಂಕದ ಆಧಾರದ ಮೇಲೆ ಇರುತ್ತದೆ.
ಕಾಲಮ್ನ ಮೇಲೆ ಸೇರ್ಪಡೆ
`df.join()` ಬಳಸಿಕೊಂಡು ಕಾಲಮ್ನ ಮೇಲೆ ಸೇರಲು, ನೀವು `on` ಪ್ಯಾರಾಮೀಟರ್ ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬೇಕು.
ಉದಾಹರಣೆ:
# Joining on a column
df_join_column = df_orders.join(df_customers.set_index('customer_id'), on='customer_id', how='left')
print(df_join_column)
ಔಟ್ಪುಟ್:
order_id customer_id product_id quantity customer_name country
0 1 101 1 2 Alice USA
1 2 102 2 1 Bob Canada
2 3 103 1 3 Charlie UK
3 4 104 3 1 NaN NaN
4 5 105 2 2 NaN NaN
ಈ ಉದಾಹರಣೆಯು `customer_id` ಕಾಲಮ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು `df_orders` ಅನ್ನು `df_customers` ನೊಂದಿಗೆ ಸೇರಿಸುವುದನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ. ಸೇರ್ಪಡೆ ಮಾಡುವ ಮೊದಲು `customer_id` ಅನ್ನು `df_customers` ನಲ್ಲಿ ಸೂಚ್ಯಂಕವಾಗಿ ಹೊಂದಿಸಲಾಗಿದೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ.
ಅತಿಕ್ರಮಿಸುವ ಕಾಲಮ್ಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು
ಡೇಟಾಫ್ರೇಮ್ಗಳನ್ನು ವಿಲೀನಗೊಳಿಸುವಾಗ ಅಥವಾ ಸೇರಿಸುವಾಗ, ಅತಿಕ್ರಮಿಸುವ ಕಾಲಮ್ ಹೆಸರುಗಳು (ಎರಡೂ ಡೇಟಾಫ್ರೇಮ್ಗಳಲ್ಲಿ ಒಂದೇ ಹೆಸರಿನ ಕಾಲಮ್ಗಳು) ಕಂಡುಬರುವುದು ಸಾಮಾನ್ಯವಾಗಿದೆ. ಪಾಂಡಾಸ್ ಈ ಪರಿಸ್ಥಿತಿಗಳನ್ನು ನಿರ್ವಹಿಸಲು `pd.merge()` ನಲ್ಲಿ `suffixes` ಪ್ಯಾರಾಮೀಟರ್ ಮತ್ತು `df.join()` ನಲ್ಲಿ `lsuffix` ಮತ್ತು `rsuffix` ಪ್ಯಾರಾಮೀಟರ್ಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ.
`pd.merge()` ನಲ್ಲಿ `suffixes` ಬಳಸುವುದು
`suffixes` ಪ್ಯಾರಾಮೀಟರ್ ಅತಿಕ್ರಮಿಸುವ ಕಾಲಮ್ ಹೆಸರುಗಳಿಗೆ ಸೇರಿಸಲಾಗುವ ಸಫಿಕ್ಸ್ಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.
ಉದಾಹರಣೆ:
# DataFrame 1: Product Information
df_products1 = pd.DataFrame({
'product_id': [1, 2, 3],
'product_name': ['Product A', 'Product B', 'Product C'],
'price': [10, 20, 15]
})
# DataFrame 2: Product Information (with potentially updated prices)
df_products2 = pd.DataFrame({
'product_id': [1, 2, 4],
'product_name': ['Product A', 'Product B', 'Product D'],
'price': [12, 18, 25]
})
# Merge with suffixes
df_merged_suffixes = pd.merge(df_products1, df_products2, on='product_id', suffixes=('_old', '_new'))
print(df_merged_suffixes)
ಔಟ್ಪುಟ್:
product_id product_name_old price_old product_name_new price_new
0 1 Product A 10 Product A 12
1 2 Product B 20 Product B 18
ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, `product_name` ಮತ್ತು `price` ಕಾಲಮ್ಗಳು ಎರಡೂ ಡೇಟಾಫ್ರೇಮ್ಗಳಲ್ಲಿ ಇರುತ್ತವೆ. `suffixes` ಪ್ಯಾರಾಮೀಟರ್ ಎಡ ಮತ್ತು ಬಲ ಡೇಟಾಫ್ರೇಮ್ಗಳಿಂದ ಕಾಲಮ್ಗಳನ್ನು ಪ್ರತ್ಯೇಕಿಸಲು `_old` ಮತ್ತು `_new` ಸಫಿಕ್ಸ್ಗಳನ್ನು ಸೇರಿಸುತ್ತದೆ.
`df.join()` ನಲ್ಲಿ `lsuffix` ಮತ್ತು `rsuffix` ಬಳಸುವುದು
`lsuffix` ಮತ್ತು `rsuffix` ಪ್ಯಾರಾಮೀಟರ್ಗಳು `df.join()` ಗಾಗಿ ಇದೇ ರೀತಿಯ ಕಾರ್ಯವನ್ನು ಒದಗಿಸುತ್ತವೆ. `lsuffix` ಎಡ ಡೇಟಾಫ್ರೇಮ್ನ ಅತಿಕ್ರಮಿಸುವ ಕಾಲಮ್ಗಳಿಗೆ ಮತ್ತು `rsuffix` ಬಲ ಡೇಟಾಫ್ರೇಮ್ನ ಅತಿಕ್ರಮಿಸುವ ಕಾಲಮ್ಗಳಿಗೆ ಸೇರಿಸುತ್ತದೆ.
ಉದಾಹರಣೆ:
# Join with lsuffix and rsuffix
df_products1_index = df_products1.set_index('product_id')
df_products2_index = df_products2.set_index('product_id')
df_joined_suffixes = df_products1_index.join(df_products2_index, lsuffix='_old', rsuffix='_new', how='outer')
print(df_joined_suffixes)
ಔಟ್ಪುಟ್:
product_name_old price_old product_name_new price_new
product_id
1 Product A 10.0 Product A 12.0
2 Product B 20.0 Product B 18.0
3 Product C 15.0 NaN NaN
4 NaN NaN Product D 25.0
ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳು ಮತ್ತು ಬಳಕೆಯ ಸಂದರ್ಭಗಳು
ಡೇಟಾಫ್ರೇಮ್ಗಳನ್ನು ವಿಲೀನಗೊಳಿಸುವುದು ಮತ್ತು ಸೇರಿಸುವುದು ವಿವಿಧ ಡೇಟಾ ವಿಶ್ಲೇಷಣೆ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ ವ್ಯಾಪಕವಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ. ಇಲ್ಲಿ ಕೆಲವು ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳಿವೆ:
ಮಾರಾಟ ಡೇಟಾವನ್ನು ಉತ್ಪನ್ನ ಮಾಹಿತಿಯೊಂದಿಗೆ ಸಂಯೋಜಿಸುವುದು
ಮಾರಾಟ ಡೇಟಾವನ್ನು ಉತ್ಪನ್ನ ಮಾಹಿತಿಯೊಂದಿಗೆ ಸಂಯೋಜಿಸುವುದು ಒಂದು ಸಾಮಾನ್ಯ ಬಳಕೆಯ ಸಂದರ್ಭವಾಗಿದೆ. ನಿಮ್ಮ ಬಳಿ ಮಾರಾಟ ವಹಿವಾಟುಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಒಂದು ಡೇಟಾಫ್ರೇಮ್ ಮತ್ತು ಉತ್ಪನ್ನ ವಿವರಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಇನ್ನೊಂದು ಡೇಟಾಫ್ರೇಮ್ ಇದೆ ಎಂದು ಭಾವಿಸೋಣ. ಉತ್ಪನ್ನ ಮಾಹಿತಿಯೊಂದಿಗೆ ಮಾರಾಟ ಡೇಟಾವನ್ನು ಸಮೃದ್ಧಗೊಳಿಸಲು ನೀವು ಈ ಡೇಟಾಫ್ರೇಮ್ಗಳನ್ನು ವಿಲೀನಗೊಳಿಸಬಹುದು.
ಉದಾಹರಣೆ:
# Sales Transactions Data
df_sales = pd.DataFrame({
'transaction_id': [1, 2, 3, 4, 5],
'product_id': [101, 102, 103, 101, 104],
'quantity': [2, 1, 3, 1, 2],
'sales_date': ['2023-01-15', '2023-02-20', '2023-03-10', '2023-04-05', '2023-05-01']
})
# Product Information Data
df_products = pd.DataFrame({
'product_id': [101, 102, 103, 104],
'product_name': ['Laptop', 'Mouse', 'Keyboard', 'Monitor'],
'category': ['Electronics', 'Electronics', 'Electronics', 'Electronics'],
'price': [1200, 25, 75, 300]
})
# Merge Sales Data with Product Information
df_sales_enriched = pd.merge(df_sales, df_products, on='product_id', how='left')
print(df_sales_enriched)
ಔಟ್ಪುಟ್:
transaction_id product_id quantity sales_date product_name category price
0 1 101 2 2023-01-15 Laptop Electronics 1200
1 2 102 1 2023-02-20 Mouse Electronics 25
2 3 103 3 2023-03-10 Keyboard Electronics 75
3 4 101 1 2023-04-05 Laptop Electronics 1200
4 5 104 2 2023-05-01 Monitor Electronics 300
ಫಲಿತಾಂಶದ ಡೇಟಾಫ್ರೇಮ್ `df_sales_enriched` ಮಾರಾಟ ವಹಿವಾಟುಗಳನ್ನು ಮತ್ತು ಅನುಗುಣವಾದ ಉತ್ಪನ್ನ ಮಾಹಿತಿಯನ್ನು ಒಳಗೊಂಡಿದೆ, ಇದು ಮಾರಾಟದ ಪ್ರವೃತ್ತಿಗಳು ಮತ್ತು ಉತ್ಪನ್ನದ ಕಾರ್ಯಕ್ಷಮತೆಯ ಹೆಚ್ಚು ವಿವರವಾದ ವಿಶ್ಲೇಷಣೆಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.
ಗ್ರಾಹಕರ ಡೇಟಾವನ್ನು ಜನಸಂಖ್ಯಾ ಮಾಹಿತಿಯೊಂದಿಗೆ ಸಂಯೋಜಿಸುವುದು
ಗ್ರಾಹಕರ ಡೇಟಾವನ್ನು ಜನಸಂಖ್ಯಾ ಮಾಹಿತಿಯೊಂದಿಗೆ ಸಂಯೋಜಿಸುವುದು ಮತ್ತೊಂದು ಸಾಮಾನ್ಯ ಬಳಕೆಯ ಸಂದರ್ಭವಾಗಿದೆ. ಇದು ಜನಸಂಖ್ಯಾ ಅಂಶಗಳ ಆಧಾರದ ಮೇಲೆ ಗ್ರಾಹಕರ ನಡವಳಿಕೆಯನ್ನು ವಿಶ್ಲೇಷಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.
ಉದಾಹರಣೆ:
# Customer Data
df_customers = pd.DataFrame({
'customer_id': [1, 2, 3, 4, 5],
'customer_name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
'city': ['New York', 'London', 'Tokyo', 'Sydney', 'Berlin']
})
# Demographic Information Data
df_demographics = pd.DataFrame({
'city': ['New York', 'London', 'Tokyo', 'Sydney', 'Berlin'],
'population': [8419000, 8982000, 13960000, 5312000, 3769000],
'average_income': [75000, 65000, 85000, 90000, 55000]
})
# Merge Customer Data with Demographic Information
df_customer_demographics = pd.merge(df_customers, df_demographics, on='city', how='left')
print(df_customer_demographics)
ಔಟ್ಪುಟ್:
customer_id customer_name city population average_income
0 1 Alice New York 8419000 75000
1 2 Bob London 8982000 65000
2 3 Charlie Tokyo 13960000 85000
3 4 David Sydney 5312000 90000
4 5 Eve Berlin 3769000 55000
ಫಲಿತಾಂಶದ ಡೇಟಾಫ್ರೇಮ್ `df_customer_demographics` ಗ್ರಾಹಕರ ಡೇಟಾವನ್ನು ಅವರ ಆಯಾ ನಗರಗಳ ಜನಸಂಖ್ಯಾ ಮಾಹಿತಿಯೊಂದಿಗೆ ಒಳಗೊಂಡಿದೆ, ಇದು ನಗರದ ಜನಸಂಖ್ಯೆಯ ಆಧಾರದ ಮೇಲೆ ಗ್ರಾಹಕರ ನಡವಳಿಕೆಯ ವಿಶ್ಲೇಷಣೆಯನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ.
ಜಾಗತಿಕ ಪೂರೈಕೆ ಸರಪಳಿ ಡೇಟಾವನ್ನು ವಿಶ್ಲೇಷಿಸುವುದು
ಪಾಂಡಾಸ್ ವಿಲೀನಗೊಳಿಸುವಿಕೆಯು ಜಾಗತಿಕ ಪೂರೈಕೆ ಸರಪಳಿ ಡೇಟಾವನ್ನು ವಿಶ್ಲೇಷಿಸಲು ಮೌಲ್ಯಯುತವಾಗಿದೆ, ಅಲ್ಲಿ ಮಾಹಿತಿಯು ಸಾಮಾನ್ಯವಾಗಿ ಅನೇಕ ಕೋಷ್ಟಕಗಳಲ್ಲಿ ಹರಡಿರುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಪೂರೈಕೆದಾರರ ಡೇಟಾ, ಶಿಪ್ಪಿಂಗ್ ಮಾಹಿತಿ ಮತ್ತು ಮಾರಾಟದ ಅಂಕಿಅಂಶಗಳನ್ನು ಲಿಂಕ್ ಮಾಡುವುದರಿಂದ ಅಡಚಣೆಗಳನ್ನು ಬಹಿರಂಗಪಡಿಸಬಹುದು ಮತ್ತು ಲಾಜಿಸ್ಟಿಕ್ಸ್ ಅನ್ನು ಉತ್ತಮಗೊಳಿಸಬಹುದು.
ಉದಾಹರಣೆ:
# Supplier Data
df_suppliers = pd.DataFrame({
'supplier_id': [1, 2, 3],
'supplier_name': ['GlobalTech', 'EuroParts', 'AsiaSource'],
'location': ['Taiwan', 'Germany', 'China']
})
# Shipping Data
df_shipments = pd.DataFrame({
'shipment_id': [101, 102, 103, 104],
'supplier_id': [1, 2, 3, 1],
'destination': ['USA', 'Canada', 'Australia', 'Japan'],
'shipment_date': ['2023-01-10', '2023-02-15', '2023-03-20', '2023-04-25']
})
# Merge Supplier and Shipment Data
df_supply_chain = pd.merge(df_shipments, df_suppliers, on='supplier_id', how='left')
print(df_supply_chain)
ಔಟ್ಪುಟ್:
shipment_id supplier_id destination shipment_date supplier_name location
0 101 1 USA 2023-01-10 GlobalTech Taiwan
1 102 2 Canada 2023-02-15 EuroParts Germany
2 103 3 Australia 2023-03-20 AsiaSource China
3 104 1 Japan 2023-04-25 GlobalTech Taiwan
ಸುಧಾರಿತ ವಿಲೀನಗೊಳಿಸುವ ತಂತ್ರಗಳು
ಬಹು ಕಾಲಮ್ಗಳ ಮೇಲೆ ವಿಲೀನಗೊಳಿಸುವುದು
`on` ಪ್ಯಾರಾಮೀಟರ್ಗೆ ಕಾಲಮ್ ಹೆಸರುಗಳ ಪಟ್ಟಿಯನ್ನು ಪಾಸ್ ಮಾಡುವ ಮೂಲಕ ನೀವು ಬಹು ಕಾಲಮ್ಗಳ ಆಧಾರದ ಮೇಲೆ ಡೇಟಾಫ್ರೇಮ್ಗಳನ್ನು ವಿಲೀನಗೊಳಿಸಬಹುದು.
ಉದಾಹರಣೆ:
# DataFrame 1
df1 = pd.DataFrame({
'product_id': [1, 1, 2, 2],
'color': ['red', 'blue', 'red', 'blue'],
'quantity': [10, 15, 20, 25]
})
# DataFrame 2
df2 = pd.DataFrame({
'product_id': [1, 1, 2, 2],
'color': ['red', 'blue', 'red', 'blue'],
'price': [5, 7, 8, 10]
})
# Merge on multiple columns
df_merged_multiple = pd.merge(df1, df2, on=['product_id', 'color'], how='inner')
print(df_merged_multiple)
ಔಟ್ಪುಟ್:
product_id color quantity price
0 1 red 10 5
1 1 blue 15 7
2 2 red 20 8
3 2 blue 25 10
ವಿಭಿನ್ನ ಕಾಲಮ್ ಹೆಸರುಗಳೊಂದಿಗೆ ವಿಲೀನಗೊಳಿಸುವುದು
ಸೇರ್ಪಡೆ ಕಾಲಮ್ಗಳು ಎರಡು ಡೇಟಾಫ್ರೇಮ್ಗಳಲ್ಲಿ ವಿಭಿನ್ನ ಹೆಸರುಗಳನ್ನು ಹೊಂದಿದ್ದರೆ, ವಿಲೀನಗೊಳಿಸಲು ಬಳಸಬೇಕಾದ ಕಾಲಮ್ ಹೆಸರುಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ನೀವು `left_on` ಮತ್ತು `right_on` ಪ್ಯಾರಾಮೀಟರ್ಗಳನ್ನು ಬಳಸಬಹುದು.
ಉದಾಹರಣೆ:
# DataFrame 1
df1 = pd.DataFrame({
'product_id': [1, 2, 3],
'product_name': ['Product A', 'Product B', 'Product C']
})
# DataFrame 2
df2 = pd.DataFrame({
'id': [1, 2, 4],
'price': [10, 20, 25]
})
# Merge with different column names
df_merged_different = pd.merge(df1, df2, left_on='product_id', right_on='id', how='left')
print(df_merged_different)
ಔಟ್ಪುಟ್:
product_id product_name id price
0 1 Product A 1.0 10.0
1 2 Product B 2.0 20.0
2 3 Product C NaN NaN
ವಿಲೀನ ವಿಶ್ಲೇಷಣೆಗಾಗಿ `indicator` ಬಳಸುವುದು
`pd.merge()` ನಲ್ಲಿನ `indicator` ಪ್ಯಾರಾಮೀಟರ್ ಫಲಿತಾಂಶದ ಡೇಟಾಫ್ರೇಮ್ಗೆ `_merge` ಎಂಬ ಕಾಲಮ್ ಅನ್ನು ಸೇರಿಸುತ್ತದೆ, ಇದು ಪ್ರತಿ ಸಾಲಿನ ಮೂಲವನ್ನು ಸೂಚಿಸುತ್ತದೆ. ಯಾವ ಸಾಲುಗಳನ್ನು ಹೊಂದಾಣಿಕೆ ಮಾಡಲಾಗಿದೆ ಮತ್ತು ಯಾವುದನ್ನು ಹೊಂದಾಣಿಕೆ ಮಾಡಲಾಗಿಲ್ಲ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ.
ಉದಾಹರಣೆ:
# Merge with indicator
df_merged_indicator = pd.merge(df_orders, df_customers, on='customer_id', how='outer', indicator=True)
print(df_merged_indicator)
ಔಟ್ಪುಟ್:
order_id customer_id product_id quantity customer_name country _merge
0 1.0 101 1.0 2.0 Alice USA both
1 2.0 102 2.0 1.0 Bob Canada both
2 3.0 103 1.0 3.0 Charlie UK both
3 4.0 104 3.0 1.0 NaN NaN left_only
4 5.0 105 2.0 2.0 NaN NaN left_only
5 NaN 106 NaN NaN David Australia right_only
`_merge` ಕಾಲಮ್ ಸಾಲು ಎರಡೂ ಡೇಟಾಫ್ರೇಮ್ಗಳಿಂದ (`both`), ಎಡ ಡೇಟಾಫ್ರೇಮ್ನಿಂದ ಮಾತ್ರ (`left_only`), ಅಥವಾ ಬಲ ಡೇಟಾಫ್ರೇಮ್ನಿಂದ ಮಾತ್ರ (`right_only`) ಆಗಿದೆಯೇ ಎಂದು ಸೂಚಿಸುತ್ತದೆ.
ವಿಲೀನ ಪ್ರಕಾರಗಳನ್ನು ಮೌಲ್ಯೀಕರಿಸುವುದು
`validate` ಪ್ಯಾರಾಮೀಟರ್ ಡೇಟಾಫ್ರೇಮ್ಗಳ ನಡುವಿನ ನಿರೀಕ್ಷಿತ ಸಂಬಂಧ ಪ್ರಕಾರಗಳೊಂದಿಗೆ (ಉದಾಹರಣೆಗೆ, 'one_to_one', 'one_to_many') ವಿಲೀನ ಕಾರ್ಯಾಚರಣೆಯು ಹೊಂದಿಕೆಯಾಗುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಇದು ಡೇಟಾ ಅಸಂಗತತೆಗಳು ಮತ್ತು ದೋಷಗಳನ್ನು ತಡೆಯಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.
ಉದಾಹರಣೆ:
# Example with one-to-one validation
df_users = pd.DataFrame({
'user_id': [1, 2, 3],
'username': ['john_doe', 'jane_smith', 'peter_jones']
})
df_profiles = pd.DataFrame({
'user_id': [1, 2, 3],
'profile_description': ['Software Engineer', 'Data Scientist', 'Project Manager']
})
# Performing a one-to-one merge with validation
merged_df = pd.merge(df_users, df_profiles, on='user_id', validate='one_to_one')
print(merged_df)
ವಿಲೀನವು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಮೌಲ್ಯೀಕರಣವನ್ನು ಉಲ್ಲಂಘಿಸಿದರೆ (ಉದಾಹರಣೆಗೆ, 'one_to_one' ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದಾಗ many-to-one ಸಂಬಂಧ), `MergeError` ಅನ್ನು ಎತ್ತಲಾಗುತ್ತದೆ, ಇದು ಸಂಭವನೀಯ ಡೇಟಾ ಸಮಗ್ರತೆ ಸಮಸ್ಯೆಗಳ ಬಗ್ಗೆ ನಿಮಗೆ ಎಚ್ಚರಿಕೆ ನೀಡುತ್ತದೆ.
ಕಾರ್ಯಕ್ಷಮತೆಯ ಪರಿಗಣನೆಗಳು
ಡೇಟಾಫ್ರೇಮ್ಗಳನ್ನು ವಿಲೀನಗೊಳಿಸುವುದು ಮತ್ತು ಸೇರಿಸುವುದು ಗಣನೀಯವಾಗಿ ದುಬಾರಿಯಾಗಬಹುದು, ವಿಶೇಷವಾಗಿ ದೊಡ್ಡ ಡೇಟಾಸೆಟ್ಗಳಿಗೆ. ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸುಧಾರಿಸಲು ಕೆಲವು ಸಲಹೆಗಳು ಇಲ್ಲಿವೆ:
- ಸೂಕ್ತವಾದ ಸೇರ್ಪಡೆ ಪ್ರಕಾರವನ್ನು ಬಳಸಿ: ಸರಿಯಾದ ಸೇರ್ಪಡೆ ಪ್ರಕಾರವನ್ನು ಆಯ್ಕೆ ಮಾಡುವುದರಿಂದ ಕಾರ್ಯಕ್ಷಮತೆಯ ಮೇಲೆ ಗಮನಾರ್ಹವಾಗಿ ಪರಿಣಾಮ ಬೀರಬಹುದು. ಉದಾಹರಣೆಗೆ, ನಿಮಗೆ ಹೊಂದಾಣಿಕೆಯ ಸಾಲುಗಳು ಮಾತ್ರ ಬೇಕಿದ್ದರೆ, ಆಂತರಿಕ ಸೇರ್ಪಡೆ (inner join) ಬಳಸಿ.
- ಸೇರ್ಪಡೆ ಕಾಲಮ್ಗಳನ್ನು ಸೂಚ್ಯಂಕ ಮಾಡಿ: ಸೇರ್ಪಡೆ ಕಾಲಮ್ಗಳನ್ನು ಸೂಚ್ಯಂಕ ಮಾಡುವುದರಿಂದ ವಿಲೀನಗೊಳಿಸುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ವೇಗಗೊಳಿಸಬಹುದು.
- ಸೂಕ್ತ ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ಬಳಸಿ: ಸೇರ್ಪಡೆ ಕಾಲಮ್ಗಳು ಹೊಂದಾಣಿಕೆಯ ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ಹೊಂದಿವೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.
- ಅನಗತ್ಯ ಪ್ರತಿಗಳನ್ನು ತಪ್ಪಿಸಿ: ಡೇಟಾದ ಅನಗತ್ಯ ಪ್ರತಿಗಳನ್ನು ರಚಿಸುವುದನ್ನು ತಪ್ಪಿಸಲು `pd.merge()` ಮತ್ತು `df.join()` ನಲ್ಲಿ `copy=False` ಅನ್ನು ಹೊಂದಿಸಿ.
ತೀರ್ಮಾನ
ಡೇಟಾ ವಿಶ್ಲೇಷಣೆಯಲ್ಲಿ ಡೇಟಾಫ್ರೇಮ್ಗಳನ್ನು ವಿಲೀನಗೊಳಿಸುವುದು ಮತ್ತು ಸೇರಿಸುವುದು ಮೂಲಭೂತ ಕಾರ್ಯಾಚರಣೆಗಳಾಗಿವೆ. ವಿಭಿನ್ನ ಸೇರ್ಪಡೆ ಪ್ರಕಾರಗಳು ಮತ್ತು ತಂತ್ರಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ, ನೀವು ವಿವಿಧ ಮೂಲಗಳಿಂದ ಡೇಟಾವನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಸಂಯೋಜಿಸಬಹುದು ಮತ್ತು ವಿಶ್ಲೇಷಿಸಬಹುದು, ಅಮೂಲ್ಯವಾದ ಒಳನೋಟಗಳನ್ನು ಅನ್ಲಾಕ್ ಮಾಡಬಹುದು ಮತ್ತು ತಿಳುವಳಿಕೆಯುಳ್ಳ ನಿರ್ಧಾರ ತೆಗೆದುಕೊಳ್ಳಲು ಸಹಾಯಕವಾಗುತ್ತದೆ. ಮಾರಾಟದ ಡೇಟಾವನ್ನು ಉತ್ಪನ್ನ ಮಾಹಿತಿಯೊಂದಿಗೆ ಸಂಯೋಜಿಸುವುದರಿಂದ ಹಿಡಿದು ಜಾಗತಿಕ ಪೂರೈಕೆ ಸರಪಳಿಗಳನ್ನು ವಿಶ್ಲೇಷಿಸುವವರೆಗೆ, ಈ ತಂತ್ರಗಳನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳುವುದು ಸಂಕೀರ್ಣ ಡೇಟಾ ಮ್ಯಾನಿಪ್ಯುಲೇಷನ್ ಕಾರ್ಯಗಳನ್ನು ವಿಶ್ವಾಸದಿಂದ ನಿಭಾಯಿಸಲು ನಿಮಗೆ ಅಧಿಕಾರ ನೀಡುತ್ತದೆ. ದೊಡ್ಡ ಡೇಟಾಸೆಟ್ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ಕಾರ್ಯಕ್ಷಮತೆಯ ಪರಿಣಾಮಗಳನ್ನು ಪರಿಗಣಿಸಲು ಮತ್ತು ಹೆಚ್ಚು ದೃಢವಾದ ಮತ್ತು ಒಳನೋಟವುಳ್ಳ ವಿಶ್ಲೇಷಣೆಗಾಗಿ `indicator` ಮತ್ತು `validate` ಪ್ಯಾರಾಮೀಟರ್ಗಳಂತಹ ಸುಧಾರಿತ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಬಳಸಿಕೊಳ್ಳಲು ಮರೆಯದಿರಿ.